home *** CD-ROM | disk | FTP | other *** search
/ Software Vault: The Gold Collection / Software Vault - The Gold Collection (American Databankers) (1993).ISO / cdr49 / cl181.zip / CL.HPP < prev    next >
C/C++ Source or Header  |  1993-04-26  |  8KB  |  312 lines
  1. /*
  2.     cl.hpp -- Container Lite v 1.81
  3.     (C) Copyright 1993  John Webster Small
  4.     All rights reserved
  5. */
  6.  
  7.  
  8. #ifndef cl_hpp
  9. #define cl_hpp
  10.  
  11. #include <limits.h>    // UINT_MAX
  12. #include <stdarg.h>
  13. #include <iostream.h>
  14. #include <iomanip.h>
  15.  
  16. /*  stream delimiters/manipulators  */
  17.  
  18. extern char memberStreamDelimiter;
  19.  
  20. inline ostream& endm(ostream& os)
  21. { return os << memberStreamDelimiter << flush; }
  22.  
  23. inline istream& nextm(istream& is)
  24. { is.get(); return is; }
  25.  
  26.  
  27. /*  cl pointer types  */
  28.  
  29. #define CLblank
  30. #define CLcmP(ID,ITEM)  \
  31.     int (*ID)(const ITEM * D1, const ITEM * D2)
  32. typedef CLcmP(voidCmP,void);
  33. #define CLcmPcast(ID,ITEM)  \
  34.     (CLcmP(CLblank,ITEM)) ID
  35. #define CLcmP0(ITEM)  CLcmPcast(0,ITEM)
  36. #define voidCmP0 ((voidCmP)0)
  37. #define CmPfnc CmP()
  38.  
  39. #define CLapplY(ID,ITEM)  \
  40.     void (*ID)(ITEM * D, va_list args)
  41. typedef CLapplY(voidApplY,void);
  42. #define CLapplYcast(ID,ITEM)  \
  43.     (CLapplY(CLblank,ITEM)) ID
  44. #define CLapplY0(ITEM)  CLapplYcast(0,ITEM)
  45. #define voidApplY0 ((voidApplY)0)
  46.  
  47. typedef struct uniquenessGimmick { int x; }
  48.     * defaultConstructor;
  49. #define defaultConstruct    ((defaultConstructor)0)
  50.  
  51.  
  52. /*  cl constants  */
  53.  
  54. #define CL_MAXNODES    ((unsigned) \
  55.             (UINT_MAX/sizeof(void *)))
  56. #define CL_LIMIT    20U
  57. #define CL_DELTA    10U
  58. #define CL_NOTFOUND    CL_MAXNODES
  59.  
  60. #define CL_SORTED    0x01U
  61. #define CL_BIND_ONLY    0x00U
  62. #define CL_DASSIGN    0x02U
  63. #define CL_DREAD    0x04U
  64. #define CL_DREAD_DEL    0x08U
  65. #define CL_DNEW    0x10U
  66. #define CL_DNEWED    0x20U
  67. #define CL_DDELETE    0x40U
  68. #define CL_DSTORE    0x80U
  69. #define CL_ALL_FLAGS    0xFFU
  70. #define CL_DANDS    CL_DASSIGN|CL_DNEW|\
  71.             CL_DDELETE|CL_DSTORE
  72.  
  73.  
  74. class cl {
  75.  
  76. private:
  77.  
  78.     void init(unsigned flags = 0U,
  79.         unsigned maxNodes = 0U,
  80.         unsigned limit = 0U,
  81.         unsigned delta =0U);
  82.  
  83.  
  84. protected:
  85.  
  86.     unsigned lowLimit, lowThreshold, first;
  87.     void **  linkS;
  88.     unsigned limit,    delta,   nodes;
  89.     unsigned maxNodes, curNode, flags;
  90.     voidCmP  cmP;
  91.  
  92.     cl  (defaultConstructor)
  93.             { init(); }
  94.     void    assign(cl& b);
  95.     void    destruct();
  96.     virtual voidCmP DcmP(voidCmP cmP)
  97.             { return cmP; }
  98.     virtual void * Dassign(void *, const void *)
  99.             { return (void *)0; }
  100.     virtual void * Dnew(const void *)
  101.             { return (void *)0; }
  102.     virtual void   Ddelete(void * D)
  103.             { delete D; }
  104.     virtual int    Dattach(void *)
  105.             { return 1; }
  106.     virtual void   Ddetach(void *)
  107.             {}
  108.     virtual    int    Dput(ostream&, void *)
  109.             { return 0; }
  110.     virtual    void * Dget(istream&) 
  111.             { return (void *)0; }
  112.     virtual int    put(ostream& os);
  113.     virtual int    get(istream& is);
  114.     int     load(const char * filename);
  115.     int     save(const char * filename);
  116.     void    vforEach(voidApplY B, va_list args);
  117.  
  118.  
  119. public:
  120.  
  121. /*  Constructors and destructor  */
  122.  
  123.     cl  (unsigned flags = CL_BIND_ONLY,
  124.         unsigned maxNodes = CL_MAXNODES,
  125.         unsigned limit = CL_LIMIT,
  126.         unsigned delta = CL_DELTA)
  127.         { init(flags,maxNodes,limit,delta); }
  128.     cl  (void ** argv, unsigned argc = 0U,
  129.         unsigned flags = CL_BIND_ONLY);
  130.     void ** vector(void ** argv = (void **)0,
  131.             unsigned argc = 0U);
  132.     virtual ~cl()  { destruct(); }
  133. /*
  134.     You must override this destructor in any
  135.     descendant that overrides Ddelete() or
  136.     Ddetach(), i.e.
  137.  
  138.     virtual ~DerivedFromCL()
  139.         { cl::destruct(); }
  140.  
  141.     This is because base destructors are called
  142.     after vfts are reset to their default values
  143.     for the base level.  This means that
  144.     cl::~cl() calls cl::Ddetach()
  145.     and perhaps cl::Ddelete() instead of
  146.     the intended DerivedFromCL::Ddetach()
  147.     or DerivedFromCL::Ddelete().
  148. */
  149.  
  150.  
  151. /*  Housekeeping Primitives  */
  152.  
  153.     unsigned Limit()  { return limit; }
  154.     unsigned setLimit(unsigned newLimit);
  155.     unsigned pack()  { return setLimit(nodes); }
  156.     unsigned Delta()  { return delta; }
  157.     unsigned setDelta(unsigned newDelta
  158.             = CL_DELTA);
  159.     unsigned Nodes()  { return nodes; }
  160.     unsigned MaxNodes()  { return maxNodes; }
  161.     unsigned setMaxNodes(unsigned newMaxNodes
  162.             = CL_MAXNODES);
  163.     unsigned vacancy()
  164.             { return maxNodes - nodes; }
  165.     unsigned vacancyNonElastic()
  166.             { return limit - nodes; }
  167.     unsigned Flags(unsigned flags = CL_ALL_FLAGS)
  168.             { return (this->flags & flags); }
  169.     unsigned setFlags(unsigned flags)
  170.             { return (this->flags |= flags); }
  171.     unsigned resetFlags(unsigned flags)
  172.             { return (this->flags &= ~flags); }
  173.     cl&  operator<<(cl& (*manipulator)
  174.             (cl&))
  175.             { return (manipulator?
  176.                 (*manipulator)(*this)
  177.                 : *this); }
  178.  
  179. /*  Elastic Array Primitives  */
  180.  
  181.     void *   atIns(unsigned n, void * D);
  182.     void *   atInsNew(unsigned n, const void * D);
  183.     void *   atRmv(unsigned n);
  184.     void     allRmv();
  185.     int      atDel(unsigned n);
  186.     void *   atDelAsg(unsigned n, void * D);
  187.     int      allDel();
  188.     void     allClr();
  189.     void *   atPut(unsigned n, void * D);
  190.     void *   atPutNew(unsigned n, const void * D);
  191.     void *   atPutAsg(unsigned n, const void * D);
  192.     void *   atGet(unsigned n);
  193.     void *   operator[](unsigned n)
  194.             { return atGet(n); }
  195.     void *   atGetAsg(unsigned n, void * D);
  196.     void *   atXchg(unsigned n, void * D);
  197.     unsigned index(const void * D);
  198.     void     forEach(voidApplY B, ...)
  199.             { va_list args;
  200.             va_start(args,B);
  201.             vforEach(B,args);    
  202.             va_end(args); }
  203.  
  204.  
  205. /*  Stack - Deque - Queue Primitives  */
  206.  
  207.     void *   push(void * D)
  208.             { return atIns(0U,D); }
  209.     void *   pushNew(const void * D)
  210.             { return atInsNew(0U,D); }
  211.     void *   pop()  { return atRmv(0U); }
  212.     cl&  operator>>(void *& D)
  213.             { D = atRmv(0U);
  214.             return *this; }
  215.     int      popDel()  { return atDel(0U); }
  216.     void *   popDelAsg(void * D)
  217.             { return atDelAsg(0U,D); }
  218.     void *   top()  { return atGet(0U); }
  219.     void *   topAsg(void * D)
  220.             { return atGetAsg(0U,D); }
  221.     void *   insQ(void * D)
  222.             { return atIns(nodes,D); }
  223.     cl&  operator<<(void * D)
  224.             { atIns(nodes,D); return *this; }
  225.     void *   insQNew(const void * D)
  226.             { return atInsNew(nodes,D); }
  227.     void *   unQ()  { return atRmv(nodes-1); }
  228.     int      unQDel()  { return atDel(nodes-1); }
  229.     void *   unQDelAsg(void * D)
  230.             { return atDelAsg(nodes-1,D); }
  231.     void *   rear()  { return atGet(nodes-1); }
  232.     void *   rearAsg(void * D)
  233.             { return atGetAsg(nodes-1,D); }
  234.  
  235. /*  List (single and double linked) Primitives  */
  236.  
  237.     unsigned CurNode();
  238.     int      setCurNode(unsigned n = CL_NOTFOUND);
  239.     void *   ins(void * D);
  240.     void *   insNew(const void * D);
  241.     void *   rmv();
  242.     int      del();
  243.     void *   delAsg(void * D);
  244.     void *   put(void * D)
  245.             { return atPut(curNode,D); }
  246.     void *   putNew(const void * D)
  247.             { return atPutNew(curNode,D); }
  248.     void *   putAsg(const void * D)
  249.             { return atPutAsg(curNode,D); }
  250.     void *   get()  { return atGet(curNode); }
  251.     void *   getAsg(void * D)
  252.             { return atGetAsg(curNode,D); }
  253.     void *   next();
  254.     void *   operator++()  { return next(); }
  255.     void *   nextAsg(void * D);
  256.     void *   prev();
  257.     void *   operator--()  { return prev(); }
  258.     void *   prevAsg(void * D);
  259.  
  260.  
  261. /* Priority Q, Set, Bag, Dictionary, Sort Primitives */
  262.  
  263.     unsigned Sorted()
  264.             { return (flags & CL_SORTED); }
  265.     void     unSort()  { flags &= ~CL_SORTED; }
  266.     void     setCmP(voidCmP cmP = voidCmP0)
  267.             { this->cmP = DcmP(cmP);
  268.             flags &= ~CL_SORTED; }
  269.     voidCmP  CmP()  { return cmP; }
  270.     int      sort(voidCmP cmP = voidCmP0);
  271.     void *   insSort(void * D);
  272.     void *   insSortNew(const void * D);
  273.     void *   insUnique(void * D);
  274.     void *   insUniqueNew(const void * D);
  275.     void *   findFirst(const void * K);
  276.     void *   findNext(const void * K);
  277.     void *   findLast(const void * K);
  278.     void *   findPrev(const void * K);
  279.     unsigned findAll(const void * K);
  280.  
  281. };    /*  class cl  */
  282.  
  283.  
  284. typedef void (*GenericFnC)();
  285. #define GenericFnC0  ((GenericFnC)0)
  286.  
  287. class FunctionRegistry : cl  {
  288.  
  289. public:
  290.     FunctionRegistry() : cl(CL_DDELETE) {}
  291.     int regFnC(GenericFnC fnC, unsigned id);
  292.     unsigned fnC_2_ID(GenericFnC fnC);
  293.     GenericFnC ID_2_fnC(unsigned id);
  294.     void forget() { allDel(); }
  295.     ~FunctionRegistry() {}
  296. };
  297.  
  298. extern  FunctionRegistry fnCv;
  299.  
  300. #define ForgetFunctions() fnCv.forget()
  301. #define RegisterFunction(fnC,id)  \
  302.         fnCv.regFnC((GenericFnC)fnC,id)
  303. #define RegisterCmP(cmP,id)  \
  304.         RegisterFunction(cmP,id)
  305. #define fnC2ID(fnC) fnCv.fnC_2_ID((GenericFnC)fnC)
  306. #define ID2fnC(id)  fnCv.ID_2_fnC(id)
  307. #define cmP2ID(cmP) fnC2ID(cmP)
  308. #define ID2cmP(id) ((voidCmP)ID2fnC(id))
  309.  
  310.  
  311. #endif  /*  cl_hpp  */
  312.